In [1]:
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
%matplotlib inline
In [2]:
data = pd.read_excel("sales_data.xlsx")
In [3]:
data.head()
Out[3]:
Data Desciption¶
In [4]:
data.describe()
Out[4]:
The describe() method returns description of feature and their interrealtions-
count - The number of not-empty values in that column.
mean - The average (mean) value of that column.
std - The standard deviation of that column.
min - the minimum value in that column.
25% - 25% percentile of column.
50% - 50% percentile of column.
75% - 75% percentile of column.
max - the maximum value in that column.
In [5]:
data.info()
In [6]:
data.isnull().sum()
Out[6]:
- Data is already formatted in correct order
- Data does not contain the Null value
- Data is already cleaned
Exploratory Data Analysis¶
Number of unique value in each column
In [7]:
for x in data.columns:
print(x,'-',len(data[x].unique()))
Correlation between each columns¶
In [8]:
data.corr()
Out[8]:
In [9]:
#Histogram using Pandas
data.hist(figsize=(16,8))
plt.show()
In [10]:
# group data by total order and plot count plot
data.groupby('TOTAL_ORDERS').count().plot(kind='bar',figsize=(20,8))
#plt.legend(loc=10)
plt.show()
In [11]:
#line plot for REVENUE and TOTAL_ORDERS columns
plt.figure(figsize=(20,6))
sns.lineplot(x='TOTAL_ORDERS',y='REVENUE',data=data)
plt.show()
In [12]:
col = ["REVENUE","TOTAL_ORDERS"]
data[col].describe()
Out[12]:
RFM MODEL¶
Data Modelling¶
In [13]:
rfm_data = data[['CustomerID','DAYSSINCELASTORDER','AVGDAYSBETWEENORDERS','REVENUE']].rename\
({'DAYSSINCELASTORDER':'RECENCY','AVGDAYSBETWEENORDERS':'FREQUENCY','REVENUE':'MONETARY'},axis=1)
In [14]:
rfm_data
Out[14]:
In [15]:
#Descriptive Statistics (Recency)
rfm_data.RECENCY.describe()
Out[15]:
In [16]:
#Recency distribution plot
import seaborn as sns
x = rfm_data['RECENCY']
ax = sns.distplot(x)
plt.show()
In [17]:
#Descriptive Statistics (Frequency)
rfm_data.FREQUENCY.describe()
Out[17]:
In [18]:
#Frequency distribution plot
import seaborn as sns
x = rfm_data['FREQUENCY']
ax = sns.distplot(x)
plt.show()
In [19]:
#Descriptive Statistics (Monetary)
rfm_data.MONETARY.describe()
Out[19]:
In [20]:
#Monetary distribution plot
import seaborn as sns
x = rfm_data['MONETARY']
ax = sns.distplot(x)
plt.show()
SCALING THE RFM DATA¶
In [21]:
from sklearn.preprocessing import StandardScaler
In [22]:
obj = StandardScaler()
In [23]:
scaled_data = pd.DataFrame(obj.fit_transform(rfm_data.drop('CustomerID',axis=1))).\
rename({0:'RECENCY',1:'FREQUENCY',2:'MONETARY'},axis=1)
scaled_data
Out[23]:
In [24]:
final_data = pd.concat([data['CustomerID'],scaled_data],axis=1)
final_data
Out[24]:
In [25]:
#Split into four segments using quantiles
quantiles = final_data.quantile(q=[0.25,0.5,0.75])
quantiles = quantiles.to_dict()
In [26]:
quantiles
Out[26]:
In [27]:
#Functions to create R, F and M segments
def RScoring(x,p,d):
if x <= d[p][0.25]:
return 1
elif x <= d[p][0.50]:
return 2
elif x <= d[p][0.75]:
return 3
else:
return 4
def FnMScoring(x,p,d):
if x <= d[p][0.25]:
return 4
elif x <= d[p][0.50]:
return 3
elif x <= d[p][0.75]:
return 2
else:
return 1
In [28]:
#Calculate Add R, F and M segment value columns in the existing dataset to show R, F and M segment values
final_data['R'] = final_data['RECENCY'].apply(RScoring, args=('RECENCY',quantiles,))
final_data['F'] = final_data['FREQUENCY'].apply(FnMScoring, args=('FREQUENCY',quantiles,))
final_data['M'] = final_data['MONETARY'].apply(FnMScoring, args=('MONETARY',quantiles,))
final_data.head()
Out[28]:
In [29]:
#Calculate and Add RFMGroup value column showing combined concatenated score of RFM
final_data['RFMGroup'] = final_data.R.map(str) + final_data.F.map(str) + final_data.M.map(str)
#Calculate and Add RFMScore value column showing total sum of RFMGroup values
final_data['RFMScore'] = final_data[['R', 'F', 'M']].sum(axis = 1)
final_data.head()
Out[29]:
In [30]:
#Assign Loyalty Level to each customer
Loyalty_Level = ['need attention', 'Potential customers','champions']
Score_cuts = pd.qcut(final_data.RFMScore, q = 3, labels = Loyalty_Level)
final_data['RFM_Loyalty_Level'] = Score_cuts.values
Final Data for our Model Building Process :¶
In [31]:
final_data.head()
Out[31]:
In [32]:
import plotly.express as px
df = px.data.iris()
fig = px.scatter_3d(final_data, x='R', y='F', z='M',color='RFM_Loyalty_Level')
fig.show()
In [33]:
plt.figure(figsize=(10,6))
sns.scatterplot(y='RFMScore',x='CustomerID',data=final_data,hue='RFM_Loyalty_Level')
Out[33]:
IMPLEMENT LOGISTIC MODEL TO OUR FINAL DATA¶
In [34]:
from sklearn.linear_model import LogisticRegression
In [35]:
log = LogisticRegression(multi_class='multinomial')
In [36]:
log_data = final_data[['R','F','M','RFM_Loyalty_Level']]
Data of our Need
In [37]:
log_data
Out[37]:
In [38]:
#Labelling the Output Column
from sklearn.preprocessing import LabelEncoder
encoder = LabelEncoder()
log_data['RFM_Lotalty_Level'] = encoder.fit_transform(log_data['RFM_Loyalty_Level'])
In [39]:
X = log_data.iloc[:,0:3]
X
Out[39]:
In [40]:
y = log_data.iloc[:,-1]
y
Out[40]:
In [41]:
log.fit(X,y)
Out[41]:
In [42]:
sample = log_data.sample(100)
x1 = sample.iloc[:,0:3]
y1 = sample.iloc[:,-1]
In [43]:
y_pred = log.predict(x1)
y_pred
Out[43]:
Accuracy¶
In [44]:
from sklearn.metrics import accuracy_score,confusion_matrix
print("Accuracy of Logistic Regression is",accuracy_score(y1,y_pred)*100,"%")
In [45]:
print("Logistic Regression Confusion Matrix\n")
pd.DataFrame(confusion_matrix(y1,y_pred),columns=list(range(0,3)))
Out[45]:
In [46]:
from mlxtend.plotting import plot_decision_regions
plot_decision_regions(X.values, y.values, log, legend=2,filler_feature_values = {2:3})
plt.show()
